home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 1994 November: Tool Chest / Dev.CD Nov 94.toast / Tool Chest / !Interfaces / Universal Interfaces 2.0a1 / PInterfaces / Types.p < prev    next >
Encoding:
Text File  |  1994-07-21  |  5.7 KB  |  303 lines  |  [TEXT/MPS ]
  1. {
  2.      File:        Types.p
  3.  
  4.      Copyright:    © 1984-1994 by Apple Computer, Inc.
  5.                  All rights reserved.
  6.  
  7.      Version:    Universal Interfaces 2.0a1.1  ETO #15, MPW prerelease.  Sunday, July 17, 1994. 
  8.  
  9.      Bugs?:        If you find a problem with this file, send the file and version
  10.                  information (from above) and the problem description to:
  11.  
  12.                      Internet:    apple.bugs@applelink.apple.com
  13.                      AppleLink:    APPLE.BUGS
  14.  
  15. }
  16.  
  17. {$IFC UNDEFINED UsingIncludes}
  18. {$SETC UsingIncludes := 0}
  19. {$ENDC}
  20.  
  21. {$IFC NOT UsingIncludes}
  22.  UNIT Types;
  23.  INTERFACE
  24. {$ENDC}
  25.  
  26. {$IFC UNDEFINED __TYPES__}
  27. {$SETC __TYPES__ := 1}
  28.  
  29. {$I+}
  30. {$SETC TypesIncludes := UsingIncludes}
  31. {$SETC UsingIncludes := 1}
  32.  
  33.  
  34. {$IFC UNDEFINED __CONDITIONALMACROS__}
  35. {$I ConditionalMacros.p}
  36. {$ENDC}
  37.  
  38. {$PUSH}
  39. {$ALIGN MAC68K}
  40. {$LibExport+}
  41.  
  42. CONST
  43.     noErr                        = 0;
  44.  
  45.     
  46. TYPE
  47. Byte = 0..255;
  48.  
  49.     SignedByte = -128..127;
  50.  
  51.     UInt8 = Byte;
  52.  
  53.     SInt8 = SignedByte;
  54.  
  55.     UInt16 = INTEGER;
  56.  
  57.     SInt16 = INTEGER;
  58.  
  59.     UInt32 = LONGINT;
  60.  
  61.     SInt32 = LONGINT;
  62.  
  63.     ByteParameter = SignedByte;
  64.  
  65.     Ptr = ^SignedByte;
  66.  
  67. {  pointer to a master pointer }
  68.     Handle = ^Ptr;
  69.  
  70. {$IFC UNDEFINED qMacApp }
  71.     IntegerPtr = ^INTEGER;
  72.  
  73.     LongIntPtr = ^LONGINT;
  74.  
  75. {$ENDC}
  76.     Fixed = LONGINT;
  77.  
  78.     FixedPtr = ^Fixed;
  79.  
  80.     Fract = LONGINT;
  81.  
  82.     FractPtr = ^Fract;
  83.  
  84.     _extended80 = RECORD
  85.         exp:                    INTEGER;
  86.         man:                    ARRAY [0..3] OF INTEGER;
  87.     END;
  88.     _extended96 = RECORD
  89.         exp:                    ARRAY [0..1] OF INTEGER;
  90.         man:                    ARRAY [0..3] OF INTEGER;
  91.     END;
  92. {$IFC GENERATING68K }
  93. { 
  94. Note: on PowerPC extended is undefined.
  95.       on 68K when mc68881 is on, extended is 96 bits.  
  96.              when mc68881 is off, extended is 80 bits.  
  97.       Some old toolbox routines require an 80 bit extended so we define extended80
  98. }
  99. {$IFC GENERATING68881 }
  100.     extended80 = _extended80;
  101.  
  102.     extended96 = extended;
  103.  
  104. {$ELSEC}
  105.     extended80 = extended;
  106.  
  107.     extended96 = _extended96;
  108.  
  109. {$ENDC}
  110. {$ELSEC}
  111.     extended80 = _extended80;
  112.  
  113.     extended96 = _extended96;
  114.  
  115. {$ENDC}
  116. {
  117. Note: float_t and double_t are "natural" computational types
  118.       (i.e.the compiler/processor can most easily do floating point
  119.       operations with that type.) 
  120. }
  121. {$IFC GENERATINGPOWERPC }
  122. { on PowerPC, double = 64-bit which is fastest.  float = 32-bit }
  123.     float_t = Single;
  124.  
  125.     double_t = Double;
  126.  
  127. {$ELSEC}
  128. { on 68K, long double (a.k.a. extended) is always the fastest.  It is 80 or 96-bits }
  129.     float_t = extended;
  130.  
  131.     double_t = extended;
  132.  
  133. {$ENDC}
  134.     wide = RECORD
  135.         hi:                        SInt32;
  136.         lo:                        UInt32;
  137.     END;
  138.     WidePtr = ^wide;
  139.  
  140.     UnsignedWide = RECORD
  141.         hi:                        UInt32;
  142.         lo:                        UInt32;
  143.     END;
  144.     UnsignedWidePtr = ^UnsignedWide;
  145.  
  146.  
  147. CONST
  148.     v                            = 0;
  149.     h                            = 1;
  150.  
  151.     
  152. TYPE
  153. VHSelect = SInt8;
  154.  
  155.     ProcPtr = Ptr;
  156.  
  157.     Register68kProcPtr = ProcPtr;  { PROCEDURE ; }
  158.  
  159.     ProcHandle = ^ProcPtr;
  160.  
  161.     UniversalProcPtr = ProcPtr;
  162.     UniversalProcHandle = ^ProcPtr;
  163.  
  164.     Str255 = STRING[255];
  165.     Str63 = STRING[63];
  166.     Str32 = STRING[32];
  167.     Str31 = STRING[31];
  168.     Str27 = STRING[27];
  169.     Str15 = STRING[15];
  170.  
  171.     StringPtr = ^Str255;
  172.     StringHandle = ^StringPtr;
  173.  
  174. { A C string is a zero terminated array of bytes.  There is no length byte.
  175.     a CStringPtr is a pointer to a C string (e.g. char* )
  176.     a ConstCStringPtr is a CStringPtr whose contents cannot be changed (e.g. const char* )
  177. }
  178.     CStringPtr = Ptr;
  179.     ConstCStringPtr = Ptr;
  180.  
  181.     ConstStr255Param = Str255;
  182.  
  183.     ConstStr63Param = Str63;
  184.  
  185.     ConstStr32Param = Str32;
  186.  
  187.     ConstStr31Param = Str31;
  188.  
  189.     ConstStr27Param = Str27;
  190.  
  191.     ConstStr15Param = Str15;
  192.  
  193.     OSErr = INTEGER;
  194.  
  195.     ScriptCode = INTEGER;
  196.  
  197.     LangCode = INTEGER;
  198.  
  199. {$IFC UNDEFINED MWERKS }
  200.     FourCharCode =  PACKED ARRAY [1..4] OF CHAR;
  201. {$ELSEC}
  202.     FourCharCode =  UNSIGNEDLONG;
  203. {$ENDC}
  204.     StyleItem = (bold,italic,underline,outline,shadow,condense,extend);
  205.     Style = SET OF StyleItem;
  206.  
  207.     OSType = FourCharCode;
  208.  
  209.     ResType = FourCharCode;
  210.  
  211.     OSTypePtr = ^OSType;
  212.  
  213.     ResTypePtr = ^ResType;
  214.  
  215.     Point = RECORD
  216.         CASE INTEGER OF
  217.         0: (
  218.             v:                            INTEGER;
  219.             h:                            INTEGER;
  220.            );
  221.         1: (
  222.             vh:                            ARRAY [0..1] OF INTEGER;
  223.            );
  224.     END;
  225.  
  226.     PointPtr = ^Point;
  227.  
  228.     Rect = RECORD
  229.         CASE INTEGER OF
  230.         0: (
  231.             top:                        INTEGER;
  232.             left:                        INTEGER;
  233.             bottom:                        INTEGER;
  234.             right:                        INTEGER;
  235.            );
  236.         1: (
  237.             topLeft:                    Point;
  238.             botRight:                    Point;
  239.            );
  240.     END;
  241.  
  242.     RectPtr = ^Rect;
  243.  
  244. { Numeric version part of 'vers' resource }
  245.     NumVersion = PACKED RECORD
  246.         majorRev:                UInt8;                                    {1st part of version number in BCD}
  247.         minorAndBugRev:            UInt8;                                    {2nd & 3rd part of version number share a byte}
  248.         stage:                    UInt8;                                    {stage code: dev, alpha, beta, final}
  249.         nonRelRev:                UInt8;                                    {revision level of non-released version}
  250.     END;
  251. { 'vers' resource format }
  252.     VersRec = RECORD
  253.         numericVersion:            NumVersion;                                {encoded version number}
  254.         countryCode:            INTEGER;                                {country code from intl utilities}
  255.         shortVersion:            Str255;                                    {version number string - worst case}
  256.         reserved:                Str255;                                    {longMessage string packed after shortVersion}
  257.     END;
  258.     VersRecPtr = ^VersRec;
  259.     VersRecHndl = ^VersRecPtr;
  260.  
  261. { Note: the 0xA9FF and 0xABFF traps are conditionally inlined in a different manner 
  262.          so that CFM 68K applications can use them }
  263.  
  264. PROCEDURE Debugger;
  265.     {$IFC NOT GENERATINGCFM}
  266.     INLINE $A9FF;
  267.     {$ENDC}
  268. PROCEDURE DebugStr(debuggerMsg: ConstStr255Param);
  269.     {$IFC NOT GENERATINGCFM}
  270.     INLINE $ABFF;
  271.     {$ENDC}
  272. PROCEDURE Debugger68k;
  273.     {$IFC NOT GENERATINGCFM}
  274.     INLINE $A9FF;
  275.     {$ENDC}
  276. PROCEDURE DebugStr68k(debuggerMsg: ConstStr255Param);
  277.     {$IFC NOT GENERATINGCFM}
  278.     INLINE $ABFF;
  279.     {$ENDC}
  280. PROCEDURE SysBreak;
  281.     {$IFC NOT GENERATINGCFM}
  282.     INLINE $303C, $FE16, $A9C9;
  283.     {$ENDC}
  284. PROCEDURE SysBreakStr(debuggerMsg: ConstStr255Param);
  285.     {$IFC NOT GENERATINGCFM}
  286.     INLINE $303C, $FE15, $A9C9;
  287.     {$ENDC}
  288. PROCEDURE SysBreakFunc(debuggerMsg: ConstStr255Param);
  289.     {$IFC NOT GENERATINGCFM}
  290.     INLINE $303C, $FE14, $A9C9;
  291.     {$ENDC}
  292.  
  293. {$ALIGN RESET}
  294. {$POP}
  295.  
  296. {$SETC UsingIncludes := TypesIncludes}
  297.  
  298. {$ENDC} {__TYPES__}
  299.  
  300. {$IFC NOT UsingIncludes}
  301.  END.
  302. {$ENDC}
  303.